{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Bagging算法\n",
    "##### 参考：https://zhuanlan.zhihu.com/p/61841728\n",
    "\n",
    "##  Bagging思路\n",
    "\n",
    "![Alt Text](https://pic1.zhimg.com/80/v2-b1b2f39e4ed19cb2ab4619f0c85490ec_720w.jpg)\n",
    "* bagging的思路是训练k个独立的基学习，对于每个基学习的结果进行结合（加权或者多数投票）来获得一个强学习器：故此有三个问题需要解决：\n",
    "* * 1、如何构造独立的弱分类器\n",
    "* * 2、如何构造基学习器\n",
    "* * 3、结合策略是什么\n",
    "\n",
    "### 如果构造“独立”\n",
    "* 想要获得泛化能力强的集成，就需要集成中的个体学习器尽可能地独立，但独立很难构造，故我们经可能地使用基学习器之间的差异较大。\n",
    "* 在此bagging使用了boostrap的思想，从m个样本的训练集中有放回地抽取m次，获得第一个样本集，用于训练第一个基学习器，以此类推可获得k个样本集供基学习器训练。由于训练数据不同，我们获得的基学习器会有很大的差异。\n",
    "* * boostrap思想：Bootstrap的思想，是生成一系列bootstrap伪样本，每个样本是初始数据有放回抽样。通过对伪样本的计算，获得统计量的分布。例如，要进行1000次bootstrap，求平均值的置信区间，可以对每个伪样本计算平均值。这样就获得了1000个平均值。对着1000个平均值的分位数进行计算，\n",
    "即可获得置信区间。已经证明，在初始样本足够大的情况下，bootstrap抽样能够无偏得接近总体的分布。\n",
    "* 使用boostrap还有另一个好处：虽然我们希望基学习器之间的差异经可能地大，但每个个体学习器的能力也不能太差，因而我们希望所有的基学习器总体上能经可能地用到所有数据，来进行有效的学习。我们希望不同的样本集之间是交叠的，boostrap恰好满足了这一点。\n",
    "\n",
    "### 基分类器的选取\n",
    "* bagging要求基分类器对样本分布敏感，常用的基分类器为决策树、神经网络。KNN、线性分类器由于过于“稳定”不适合作为基分类器。\n",
    "* * 树的节点分裂随机选择特征子集带来随机性，设定层数来控制泛化；\n",
    "* * 神经网络通过调整神经元数量、连接方式、网络层数、初始权值引入随机性；\n",
    "\n",
    "### boostrap 带来的“包外估计”\n",
    "* 由于使用了boostrap进行训练集的抽取，由于其抽泣方法的特性，会有约0.368的样本未被抽到，此部分样本称为包外样本（记作oobs），可用作测试集，此部分的测试结果称为“包外估计”，为真实误差的无偏估计。（无偏估计待证明）\n",
    "* obbs估计等价于k折交叉验证，使用obbs作为测试集能大幅减少计算。\n",
    "\n",
    "### 结合策略\n",
    "* 对于分类问题，我们使用多数表决；对于回归问题，我们使用平均法。\n",
    "* 结合策略是bagging方法控制方差的根源所在！使用多数表决或平均法能有效控制方差\n",
    "* 当然也有其他的结合策略。在此，可以，但没必要！\n",
    "\n",
    "## bagging的优势\n",
    "* 1.bagging关注于减小预测方差，随着基学习器数量的增加，理论上可以使分类误差降为0。\n",
    "* 记每个基分类器的分类误差 \n",
    "![Alt Text](https://www.zhihu.com/equation?tex=P%28h_%7Bi%7D%28x%29+%5Cne+f%28x%29%29+%3D+%5Cepsilon+)\n",
    "\n",
    "* 总数为T个的集成学习器总分类误差 \n",
    "![Alt Text](https://www.zhihu.com/equation?tex=H%28x%29+%3D+sign%28%5Csum_%7Bi+%3D+1%7D%5E%7BT%7D%7Bh_%7BI%7D%28x%29%7D%29)\n",
    "\n",
    "* 由Hoeffding inequality，且总分类误差在T取+∞时趋近于0\n",
    "![Alt Text](https://www.zhihu.com/equation?tex=P%28H%28x%29+%5Cne+f%28x%29%29+%3D+%5Csum_%7Bk+%3D+0%7D%5E%7B%5BT%2F2%5D%7D%7B%281+-+%5Cepsilon%29%5E%7Bk%7D%5Cepsilon%5E%7BT+-+k%7D+%5Cleq+exp%28-%5Cfrac%7B1%7D%7B2%7DT%282%5Cepsilon+-+1%29%5E%7B2%7D%7D%29)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 随机森林——bagging的代表\n",
    "\n",
    "### 随机森林的优点\n",
    "* 有效运行于大数据集：来自boostrap的样本随机选取\n",
    "* 能处理高维特征，且无需降维：来自特征的随机选取\n",
    "* 能评估各个特征在分类问题上的重要性：来自决策树\n",
    "* 能够获取到内部生成误差的一个无偏估计：由包外估计提供，来源是boostrap\n",
    "* 对异常值不敏感：来自boostrap的样本随机选取\n",
    "* 能够很好地处理缺省（待探究原因）：来自决策树\n",
    "\n",
    "### 随机森林的缺点\n",
    "* 容易受噪声影响而过拟合：主要是回归时使用均方误差作为损失函数，易受噪声影响是均方误差的通病\n",
    "* m取值影响较大\n",
    "\n",
    "### 随机森林的训练过程（两个随机）\n",
    "* 样本集N，共N个样本；特征集M，共M个特征\n",
    "* （1）样本集N中以boostrap方法抽取k个训练集，每个训练集样本个数为n（第一个随机，随机有放回抽取），且分类误差取决于：\n",
    "* * 每棵树的分类能力：单棵树分类能力越强，分类误差越小\n",
    "* * 树之间的相关性：树之间的相关性越小，分类误差越小\n",
    "\n",
    "* （2）对每个训练集，抽取M个特征中的m个特征（随机无放回抽取）：\n",
    "* * M较大时：\n",
    "![alt text](https://www.zhihu.com/equation?tex=m+%3D+log_%7B2%7DM+%E6%88%96+m+%3D+log_%7B2%7DM+%2B1)\n",
    "* * M较小时，在M中取L个特征（L<k），用[-1, +1]上的均匀分布来构建权重对L个特征进行线性组合，构成k个特征；\n",
    "* * m越小，相关性越小、分类能力越差；\n",
    "* * 是随机森林唯一的超参（在不考虑树本身的超参前提下），可以使用obb error（out of bag error）进行选择\n",
    "\n",
    "* （3）对某n个样本的训练集，m个特征的特征集进行决策树训练\n",
    "* * 只训练二叉树:减少计算量；方便模型的构建\n",
    "* * 无需剪枝：满足差异性；减少计算量\n",
    "\n",
    "* （4）分类问题使用多数表决作为结合策略，回归问题使用取平均机制\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3、sklearn + bagging 的小结\n",
    "* 参考：https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.BaggingClassifier.html\n",
    "\n",
    "* sklearn.ensemble.BaggingClassifier\n",
    "* * class sklearn.ensemble.BaggingClassifier(base_estimator=None, n_estimators=10, max_samples=1.0, max_features=1.0, bootstrap=True, bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=None, random_state=None, verbose=0)[source]¶\n",
    "\n",
    "* Bagging分类器是一个集合元估计器，它使每个基本分类器适合原始数据集的随机子集，然后将单个预测（通过投票或平均）进行汇总形成最终预测。通过将随机化引入其构造过程中，然后使其整体，这种元估计器通常可以用作减少黑盒估计器（例如决策树）方差的一种方式。\n",
    "\n",
    "\n",
    "## 参量\n",
    "* base_estimator ： object or None, optional (default=None)\n",
    "* * 基本估计量适合数据集的随机子集。如果为None，则基本估计量为决策树。\n",
    "\n",
    "* n_estimators  ：int, optional (default=10)\n",
    "* * 集合中的基本估计量。\n",
    "\n",
    "* max_samples  ：int or float, optional (default=1.0)\n",
    "* * 从X抽取以训练每个基本估计量的样本数。\n",
    "* * * 如果为int，则抽取max_samples样本。\n",
    "* * * 如果漂浮，则抽取样品。max_samples * X.shape[0]\n",
    "\n",
    "* max_features ：int or float, optional (default=1.0)\n",
    "* * 从X绘制以训练每个基本估计量的要素数量。\n",
    "* * * 如果为int，则绘制max_features特征。\n",
    "* * * 如果是浮动的，则绘制特征。max_features * X.shape[1]\n",
    "\n",
    "* bootstrap ： boolean, optional (default=True)\n",
    "* * 是否抽取样本进行替换。如果为False，则执行不替换的采样。\n",
    "\n",
    "* bootstrap_features  ：boolean, optional (default=False)\n",
    "* * 是否用替换绘制特征。\n",
    "\n",
    "* oob_score ： bool, optional (default=False)\n",
    "* * 是否使用现成的样本来估计泛化误差。\n",
    "\n",
    "* warm_start  ：bool, optional (default=False)\n",
    "* * 设置为True时，请重用上一个调用的解决方案以适合并为集合添加更多估计量，否则，仅适合一个全新的集合。\n",
    "\n",
    "* n_jobs  ： int or None, optional (default=None)\n",
    "* * fit和 并行运行的作业数predict。None除非joblib.parallel_backend上下文中，否则表示1 。-1表示使用所有处理器。有关更多详细信息，请参见词汇表。\n",
    "\n",
    "* random_stateint, RandomState instance or None, optional (default=None)\n",
    "* * 如果为int，则random_state是随机数生成器使用的种子；否则为false。如果是RandomState实例，则random_state是随机数生成器；如果为None，则随机数生成器是所使用的RandomState实例np.random。\n",
    "\n",
    "* verbose  ：int, optional (default=0)\n",
    "* * 控制拟合和预测时的详细程度。\n",
    "\n",
    "## 属性\n",
    "* base_estimator_ 估计器\n",
    "* * 从中生长集合的基本估计量。\n",
    "\n",
    "* n_features_ int\n",
    "* * fit执行时功能的数量。\n",
    "\n",
    "* estimators_估算器列表\n",
    "* * 拟合基础估计量的集合。\n",
    "\n",
    "* estimators_samples_数组列表\n",
    "* * 每个基本估计量的抽取样本的子集。\n",
    "\n",
    "* estimators_features_ 数组列表\n",
    "* * 每个基本估计量的绘制要素子集。\n",
    "\n",
    "* classes_ 形状的数组（n_classes，）\n",
    "* * 类标签。\n",
    "\n",
    "* n_classes_ int或列表\n",
    "* * 类数。\n",
    "\n",
    "* oob_score_ float\n",
    "* * 使用袋外估计获得的训练数据集的分数。仅当oob_score为True 时，此属性才存在。\n",
    "\n",
    "* oob_decision_function_ 形状的数组（n_samples，n_classes）\n",
    "* * 使用训练集上的实际估计值计算的决策函数。如果n_estimators小，则有可能在引导过程中从未遗漏任何数据点。在这种情况下， oob_decision_function_可能包含NaN。仅当oob_score为True 时，此属性才存在。\n",
    "\n",
    "## 方法\n",
    "\n",
    "|方法|含义|\n",
    "|-----------------------|:-----------------------------|\n",
    "|decision_function(self, X)|基本分类器决策函数的平均值|\n",
    "|fit(self, X, y[, sample_weight])|从培训中建立一个估计的袋装合奏|\n",
    "|get_params(self[, deep])|获取此估计量的参数|\n",
    "|predict(self, X)|预测x的类|\n",
    "|predict_log_proba(self, X)|预测x的类的对数概率|\n",
    "|predict_proba(self, X)|预测x的类的概率|\n",
    "|score(self, X, y[, sample_weight])|返回给定测试数据和标签上的平均值|\n",
    "|set_params(self, \\*\\*params)|设置此估计器的参数|\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-23T14:20:34.345701Z",
     "start_time": "2020-04-23T14:20:34.265811Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n",
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\svm\\base.py:193: FutureWarning: The default value of gamma will change from 'auto' to 'scale' in version 0.22 to account better for unscaled features. Set gamma explicitly to 'auto' or 'scale' to avoid this warning.\n",
      "  \"avoid this warning.\", FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([1])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 例子\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import BaggingClassifier\n",
    "from sklearn.datasets import make_classification\n",
    "\n",
    "x,y = make_classification(n_samples=100,n_features=4,n_informative=2,n_redundant=0,random_state=0,shuffle=False)\n",
    "clf = BaggingClassifier(base_estimator=SVC(),n_estimators=10,random_state=0).fit(x,y)\n",
    "\n",
    "clf.predict([[0,0,0,0]])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 随机森林实例\n",
    "* class sklearn.ensemble.RandomForestClassifier(n_estimators=100, criterion='gini', max_depth=None, min_samples_split=2, min_samples_leaf=1, min_weight_fraction_leaf=0.0, max_features='auto', max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, bootstrap=True, oob_score=False, n_jobs=None, random_state=None, verbose=0, warm_start=False, class_weight=None, ccp_alpha=0.0, max_samples=None）\n",
    "\n",
    "## A random forest classifier.\n",
    "\n",
    "### 参量：\n",
    "* n_estimators : 整数，可选（默认值是100）\n",
    "* * 森林中数目的数量\n",
    "* * 在版本0.22中更改：默认值n_estimators在0.22中从10更改为100。\n",
    "\n",
    "* criterion ： 字符串， 可选（默认是\"gini\"）\n",
    "* * 衡量分隔质量的功能。支持的标准是对基尼杂质的“基尼”和对信息增益的“熵”。注意：此参数是特定于树的。\n",
    "\n",
    "* max_depth : 整数或无，可选（默认为无）\n",
    "* * 树的最大深度。如果为None，则将节点展开，直到所有叶子都是纯净的，或者直到所有叶子都包含少于min_samples_split个样本。\n",
    "\n",
    "* min_samples_split  : int，float，可选（默认值= 2）\n",
    "* * 拆分内部节点所需的最少样本数：\n",
    "* * * 如果为int，则认为min_samples_split是最小值。\n",
    "* * * 如果为float，min_samples_split则为分数， 是每个拆分的最小样本数。ceil(min_samples_split * n_samples)\n",
    "\n",
    "* min_weight_fraction_leaf : float，可选（默认=0。）\n",
    "* * 在所有叶节点处（所有输入样本）的权重总和中的最小加权分数。如果未提供sample_weight，则样本的权重相等。\n",
    "\n",
    "* max_features : int，float，string或None，可选（默认=“ auto”）\n",
    "* * 寻找最佳分割时要考虑的功能数量：\n",
    "* * * 如果为int，则max_features在每个分割处考虑特征。\n",
    "* * * 如果为float，max_features则为小数，并 在每次拆分时考虑要素。int(max_features * n_features)\n",
    "* * * 如果“自动”，则max_features=sqrt(n_features)。\n",
    "* * * 如果为“ sqrt”，则max_features=sqrt(n_features)（与“ auto”相同）。\n",
    "* * * 如果为“ log2”，则为max_features=log2(n_features)。\n",
    "* * * 如果没有，则max_features=n_features。\n",
    "###### 注意：在找到至少一个有效的节点样本分区之前，分割的搜索不会停止，即使它需要有效检查多个max_features要素也是如此。\n",
    "\n",
    "* max_leaf_nodes  : int或None，可选（默认值：None）\n",
    "* * max_leaf_nodes以最好的方式种植树木。最佳节点定义为杂质的相对减少。如果为None，则叶节点数不受限制。\n",
    "\n",
    "* min_impurity_decrease : float，可选（默认=0。）\n",
    "* * 如果节点分裂会导致杂质的减少大于或等于该值，则该节点将被分裂。\n",
    "* * 加权杂质减少方程如下：\n",
    "\n",
    "        N_t / N * (impurity - N_t_R / N_t * right_impurity\n",
    "                    - N_t_L / N_t * left_impurity)\n",
    "\n",
    "* * * 其中，N是样本总数，N_t是当前节点上N_t_L的样本数，是左子节点中的样本N_t_R数，是右子节点中的样本数。\n",
    "* * * N，N_t，N_t_R并且N_t_L都指的是加权和，如果sample_weight获得通过。\n",
    "\n",
    "* min_impurity_split : float，（默认值= 1e-7）\n",
    "* * 树木生长尽早停止的阈值。如果节点的杂质高于阈值，则该节点将分裂，否则为叶。\n",
    "* * * 从版本0.19min_impurity_split开始不推荐使用：在版本0.19中不再推荐使用 min_impurity_decrease。默认值 min_impurity_split将在0.23中从1e-7更改为0，并在0.25中将其删除。使用min_impurity_decrease代替。\n",
    "\n",
    "* bootstrap  : 布尔值，可选（默认= True）\n",
    "* * 建立树木时是否使用引导程序样本。如果为False，则整个数据集将用于构建每棵树。\n",
    "\n",
    "* oob_score :  bool（默认= False）\n",
    "* * 是否使用袋外样本来估计泛化精度。\n",
    "\n",
    "* n_jobs : int或None（可选）（默认为None）\n",
    "* * 要并行运行的作业数。fit，predict， decision_path并且apply都在并行的树木。None除非joblib.parallel_backend 上下文中，否则表示1 。-1表示使用所有处理器。\n",
    "\n",
    "* random_state int，RandomState实例或无，可选（默认值：无）\n",
    "* * 控制构建树时使用的示例的自举的随机性（if bootstrap=True）和在每个节点上寻找最佳分割时要考虑的要素采样（if ）。有关详细信息，请参见词汇表。max_features < n_features\n",
    "\n",
    "* verbose : int，可选（默认= 0）\n",
    "* * 控制拟合和预测时的详细程度。\n",
    "\n",
    "* warm_start  : bool，可选（默认= False）\n",
    "* * 设置True为时，请重用上一个调用的解决方案以适应并向集合添加更多估计量，否则，仅适应一个全新的森林。\n",
    "\n",
    "* class_weight 字典，字典列表，“ balanced”，“ balanced_subsample”或“ None”（可选）（默认为“无”）\n",
    "* * 与形式的类有关的权重。如果未给出，则所有类都应具有权重一。对于多输出问题，可以按与y列相同的顺序提供字典列表。{class_label: weight}\n",
    "* * “平衡”模式使用y的值来自动调整与输入数据中的类频率成反比的权重，如下所示： n_samples / (n_classes * np.bincount(y))\n",
    "* * “ balanced_subsample”模式与“ balanced”相同，不同之处在于，权重是根据每个树生长的引导程序样本计算的。\n",
    "* * 对于多输出，y的每一列的权重将相乘。\n",
    "###### 请注意，如果指定了sample_weight，则这些权重将与sample_weight（通过fit方法传递）相乘。\n",
    "\n",
    "* ccp_alpha : 非负浮点数，可选（默认值= 0.0）\n",
    "* * 用于最小化成本复杂性修剪的复杂性参数。具有最大成本复杂度的子树小于ccp_alpha所选择的子树 。默认情况下，不执行修剪。有关详细信息，请参见 最小化成本复杂性修剪。\n",
    "\n",
    "* max_samples :int或float，默认=无\n",
    "* * 如果bootstrap为True，则从X抽取以训练每个基本估计量的样本数\n",
    "* * * 如果为无（默认），则抽取X.shape[0]样本。\n",
    "* * * 如果为int，则抽取max_samples样本。\n",
    "* * * 如果漂浮，则抽取样品。因此， 应在间隔内。max_samples * X.shape[0]max_samples(0, 1)\n",
    "\n",
    "### 属性\n",
    "* base_estimator_ DecisionTreeClassifier\n",
    "* * 子估算器模板用于创建拟合子估算器的集合。\n",
    "\n",
    "* estimators_ DecisionTreeClassifier的列表\n",
    "* * 拟合子估计量的集合。\n",
    "\n",
    "* classes_ 形状的数组（n_classes）或此类数组的列表\n",
    "* * 类标签（单输出问题）或类标签数组的列表（多输出问题\n",
    "\n",
    "* n_classes_ int或列表\n",
    "* * 类数（单个输出问题），或包含每个输出的类数的列表（多输出问题）。\n",
    "\n",
    "* n_features_ int\n",
    "* * fit执行时功能的数量。\n",
    "\n",
    "* n_outputs_ int\n",
    "* * fit执行时的输出数量。\n",
    "\n",
    "* feature_importances_形状的ndarray（n_features，）\n",
    "* * 返回功能的重要性（越高，功能越重要）。\n",
    "\n",
    "* oob_score_ float\n",
    "* * 使用袋外估计获得的训练数据集的分数。仅当oob_score为True 时，此属性才存在。\n",
    "\n",
    "* oob_decision_function_ 形状的数组（n_samples，n_classes）\n",
    "* * 使用训练集上的实际估计值计算的决策函数。如果n_estimators小，则有可能在引导过程中从未遗漏任何数据点。在这种情况下， oob_decision_function_可能包含NaN。仅当oob_score为True 时，此属性才存在。\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-24T14:50:48.029018Z",
     "start_time": "2020-04-24T14:50:47.823486Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "F:\\Anaconda\\lib\\site-packages\\sklearn\\ensemble\\forest.py:245: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.\n",
      "  \"10 in version 0.20 to 100 in 0.22.\", FutureWarning)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "RandomForestClassifier(bootstrap=True, class_weight=None, criterion='gini',\n",
       "                       max_depth=2, max_features='auto', max_leaf_nodes=None,\n",
       "                       min_impurity_decrease=0.0, min_impurity_split=None,\n",
       "                       min_samples_leaf=1, min_samples_split=2,\n",
       "                       min_weight_fraction_leaf=0.0, n_estimators=10,\n",
       "                       n_jobs=None, oob_score=False, random_state=0, verbose=0,\n",
       "                       warm_start=False)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 实例\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.datasets import make_classification\n",
    "\n",
    "x, y = make_classification(n_samples=1000, n_features=4,n_informative=2, n_redundant=0, random_state=0, shuffle=False)\n",
    "clf = RandomForestClassifier(max_depth=2,random_state=0)\n",
    "clf.fit(x,y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-24T14:51:06.242151Z",
     "start_time": "2020-04-24T14:51:06.120479Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.17287856 0.80608704 0.01884792 0.00218648]\n"
     ]
    }
   ],
   "source": [
    "print(clf.feature_importances_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-04-24T14:51:14.847481Z",
     "start_time": "2020-04-24T14:51:14.808553Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n"
     ]
    }
   ],
   "source": [
    "print(clf.predict([[0, 0, 0, 0]]))"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### \n",
    "![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 包外错误率\n",
    "* 构建随机森林的另一个关键问题就是如何选择最优的m（特征个数），要解决这个问题主要依据计算袋外错误率oob error（out-of-bag error）。\n",
    "\n",
    "　　  随机森林有一个重要的优点就是，没有必要对它进行交叉验证或者用一个独立的测试集来获得误差的一个无偏估计。它可以在内部进行评估，也就是说在生成的过程中就可以对误差建立一个无偏估计。\n",
    "\n",
    "　　  我们知道，在构建每棵树时，我们对训练集使用了不同的bootstrap sample（随机且有放回地抽取）。所以对于每棵树而言（假设对于第k棵树），大约有1/3的训练实例没有参与第k棵树的生成，它们称为第k棵树的oob样本。\n",
    "\n",
    "　　而这样的采样特点就允许我们进行oob估计，它的计算方式如下：\n",
    "\n",
    "　　（note：以样本为单位）\n",
    "\n",
    "　　1）对每个样本，计算它作为oob样本的树对它的分类情况（约1/3的树）；\n",
    "\n",
    "　　2）然后以简单多数投票作为该样本的分类结果；\n",
    "\n",
    "　　3）最后用误分个数占样本总数的比率作为随机森林的oob误分率。\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
